First PR of Ship 8 (sink-side with_rgba / with_rgba_u16 for every existing source format). Lands the template-validating slice: end-to-end RGBA support for Yuv420p only — public API, all five SIMD backends, MixedSinker integration, per-backend equivalence tests. The remaining ~30 kernel families (NV12, NV21, Yuv422p, Yuv444p, all bit-depth variants, P010 / P016 / P210 / P410, etc.) inherit the same const-generic-ALPHA template via mechanical mass-apply in follow-up PRs — see What's deferred below.

Scope

Sink-side only (the high-value half per docs/color-conversion-functions.md § Ship 8). YUVA source frames + per-pixel alpha pass-through are deferred to a follow-up PR. Default alpha is 0xFF (opaque) for sources that don't carry an alpha plane — every YUV format shipped today.

use colconv::{
    frame::Yuv420pFrame,
    sinker::MixedSinker,
    yuv::{Yuv420p, yuv420p_to},
    ColorMatrix,
};

let frame = Yuv420pFrame::new(&yp, &up, &vp, w, h, w, w / 2, w / 2);
let mut rgba = vec![0u8; (w * h * 4) as usize];
let mut sinker = MixedSinker::<Yuv420p>::new(w as usize, h as usize)
    .with_rgba(&mut rgba)?;

yuv420p_to(&frame, /*full_range=*/ true, ColorMatrix::Bt709, &mut sinker)?;
// Each pixel: rgba[4*i..4*i+3] = R,G,B; rgba[4*i+3] = 0xFF.

Design: const-generic ALPHA: bool kernel template

The natural alternatives:

1. Compose-and-expand — kernel writes 3-byte RGB to scratch, then a second pass expands to 4-byte RGBA with constant alpha. Zero new SIMD code, but ~7W bytes/row of memory traffic vs. native's 4W → roughly 1.5–2× slower for the RGBA-only path.
2. Fully forked native — kernel forked into RGB and RGBA copies per backend. Best speed, ~5–10× LOC duplication across 30+ kernels.
3. Const-generic ALPHA (this PR) — kernel body monomorphized on <const ALPHA: bool>; the only delta is the final per-block store (vst3q_u8 ↔ vst4q_u8 on NEON; new write_rgba_* shuffle helpers on x86 / wasm parallel to the existing write_rgb_*). Same speed as native, ~1/5th the LOC. Compiler DCE eliminates the if ALPHA branch and the unused alpha-vector splat at each call site.

All five backends keep R / G / B in separate vectors at store time, so adding alpha is purely a 4th vector + different shuffle/store — no re-interleave.

What's in this PR

Public API (colconv::sinker)

• MixedSinker<Yuv420p>::with_rgba(&mut [u8]) and set_rgba — attaches a packed 32-bit RGBA buffer (width × height × 4 bytes). Format-specific impl block (not on the generic MixedSinker<F>), so attaching RGBA to a sink whose process doesn't write it is a compile error rather than a silent stale-buffer bug. Future formats add their own impl blocks as RGBA support lands; a compile_fail doctest pins this property.
• MixedSinker::produces_rgba() / produces_rgba_u16() — generic queries (always false for sinks without a write path; symmetrical with the existing produces_rgb_u16()).
• MixedSinkerError::RgbaBufferTooShort { expected, actual } and RgbaU16BufferTooShort — new error variants.
• row::yuv_420_to_rgba_row(...) — public dispatcher mirroring yuv_420_to_rgb_row(...). Same contract; rgba_out.len() >= 4 * width.

Per-backend kernels (src/row/)

The 4-byte stride aligns cleanly with the 16-byte register width on every backend, so the RGBA shuffle masks are simpler than the 3-byte RGB pattern (no channel "split across blocks" at the 16-byte boundary). NEON's vst4q_u8 is a native 4-channel store — zero shuffle overhead vs. the 3-channel vst3q_u8.

MixedSinker integration

MixedSinker<Yuv420p>::process runs the RGBA path as an independent kernel call (not compose). The const-generic-ALPHA monomorphization means yuv_420_to_rgba_row::<true> and yuv_420_to_rgb_row::<false> are separate functions sharing one source body — both fully inlined at their respective call sites with the unused branch eliminated.

SIMD coverage

Block sizes per iteration mirror the existing RGB kernels: NEON / SSE4.1 / wasm = 16 px; AVX2 = 32 px; AVX-512 = 64 px.

Tests

Format-level (5 tests in src/sinker/mixed.rs):

• rgba_only_converts_gray_to_gray_with_opaque_alpha — gray YUV → gray RGB + alpha = 0xFF.
• rgba_alpha_is_opaque_for_arbitrary_color — alpha is 0xFF for non-gray content.
• with_rgb_and_with_rgba_produce_byte_identical_rgb_bytes — cross-format invariant: alpha is the only difference between with_rgb and with_rgba outputs.
• rgba_with_simd_false_matches_with_simd_true — SIMD ≡ scalar parity across 8 widths covering all backend block sizes (16 / 32 / 64) plus tails.
• rgba_buffer_too_short_returns_err — short buffer rejected at with_rgba call.
• yuv_420_to_rgba_simd_matches_scalar_with_random_yuv — pseudo-random per-pixel YUV (width 1922, all 4 matrices × both ranges) catches lane-order corruption that solid-color tests would miss.

Per-backend equivalence (18 tests in src/row/arch/*.rs):

• 4 tests per backend (NEON, SSE4.1, AVX2, AVX-512) + 2 tests for wasm = 18 total. Each calls its backend's unsafe yuv_420_to_rgba_row directly under runtime feature detection, comparing against scalar::yuv_420_to_rgba_row byte-for-byte. Bypasses the dispatcher so every backend gets exercised on every CI runner regardless of which tier the dispatcher would pick.
• Mismatch diagnostics report (byte, pixel, channel R/G/B/A, width, matrix, full_range, scalar_value, simd_value) — first divergence is locally diagnosable.

Compile-fail doctest in MixedSinker<Yuv420p>::with_rgba proves attaching RGBA to a non-Yuv420p sink (e.g. MixedSinker::<Nv12>::new(...).with_rgba(...)) is a compile error.

Local results (aarch64 macOS): 429 lib tests + 1 doctest pass.

CI matrix coverage (already wired in .github/workflows/):

• test-sde-avx512 (Intel SDE Ice Lake) — AVX-512 path.
• test jobs on AMD EPYC ubuntu-latest / macOS aarch64 — AVX2 / NEON.
• coverage.yml per-tier matrix with --cfg colconv_disable_avx512 / --cfg colconv_disable_avx2 / --cfg colconv_force_scalar — exercises SSE4.1 + scalar fallback paths.
• cross job — wasm32-wasip1 test suite exercises the wasm RGBA tests.

What's deferred

Out of scope for this PR (follow-up work):

1. Mass-apply the const-ALPHA template to the remaining ~30 kernel families. The template is mechanical; each format ships in its own bite-sized PR. Order roughly: 4:2:0 family (NV12 / NV21) → 4:2:2 (Yuv422p / NV16) → 4:4:4 (Yuv444p / NV24 / NV42) → high-bit-depth (Yuv420p9/10/12/14/16, P010/P012/P016, Yuv422p_n, Yuv444p_n, P210/P212/P216, P410/P412/P416, Bayer / Bayer16).
2. with_rgba_u16 — native-depth u16 RGBA output for high-bit-depth sources. Error variant + format-specific impl pattern is already in place; just needs wiring per format.
3. YUVA source frame types (Yuv420pAFrame etc.) — when a source carries an alpha plane, the kernel copies it through to the RGBA buffer instead of writing the opaque default. Doc roadmap calls this the "source-side half" of Ship 8.
4. Bench yuv_420_to_rgba vs. yuv_420_to_rgb — confirm the const-ALPHA path doesn't regress the RGB baseline and measure the RGBA throughput delta. Mechanically straightforward; deferred to keep this PR focused.

Test plan

• CI green on test, test-sde-avx512, cross, coverage, clippy, build jobs.
• Manually verify a Yuv420p → RGBA pipeline end-to-end with a real frame (gray patch, full red patch).
• Confirm the compile_fail doctest still rejects MixedSinker::<Nv12>::new(...).with_rgba(...).
• cargo doc --lib --no-deps clean (no new doc warnings vs. main).

🤖 Generated with Claude Code